import { BattleMap } from './BattleMap';
import { BuildingConfig, isResourceTildeType, TERRAIN_NAMES, UnitConfig, COMMAND_TYPE_NAMES, ENTITY_TYPE_NAMES, ENTITY_ROLE_NAMES, COMMON_NAMES, BATTLE_STATUS_NAMES, TERRAIN_TYPE_NAMES } from './Const';
import { BattleStatus, BuildingType, CommandType, EntityType, TildeType, UnitType } from './Enums';
import { BattleMemModel, BuildingModel, CommandParam, CommandParamMap, UnitModel } from './Model';

/**
 * 命令校验器类
 * 负责验证各种战斗命令的有效性
 */
export class CommandValidator {
    private map: BattleMap;

    constructor(map: BattleMap) {
        this.map = map;
    }

    /**
     * 通用实体获取方法
     * @param entityType 实体类型
     * @param entityId 实体ID
     * @returns 实体对象或null
     */
    private getEntity(entityType: EntityType, entityId: number): UnitModel | BuildingModel | null {
        if (entityType === EntityType.unit) {
            return this.map.getUnit(entityId);
        } else if (entityType === EntityType.building) {
            return this.map.getBuilding(entityId);
        }
        return null;
    }

    /**
     * 获取实体的配置信息
     * @param entity 实体
     * @param entityType 实体类型
     * @returns 配置信息或错误
     */
    private getEntityConfig(entityType: EntityType, entityId: number): { valid: boolean; config?: any; error?: string } {
        const entity = this.getEntity(entityType, entityId);
        if (!entity) {
            return { valid: false, error: `未知实体: ${entityId}` };
        }
        if (entityType === EntityType.unit) {
            return { valid: true, config: UnitConfig[entity.type] };
        } else if (entityType === EntityType.building) {
            return { valid: true, config: BuildingConfig[entity.type] };
        } else {
            const selfTypeName = entityType === EntityType.terrain ? '地形' : COMMON_NAMES.unknownType;
            return { valid: false, error: `实体类型错误 - 期望: 单位或建筑, 实际: ${selfTypeName}` };
        }
    }

    /**
     * 状态前置校验
     * @param battleMem 战斗缓存模型
     * @param player 玩家ID
     * @returns 验证结果
     */
    public validateRoundCommands(
        battleMem: BattleMemModel,
        player: string,
    ): { valid: boolean; error?: string } {
        // 检查战斗状态
        if (battleMem.status !== BattleStatus.running) {
            const statusName = BATTLE_STATUS_NAMES[battleMem.status] || BATTLE_STATUS_NAMES.unknown;
            return { valid: false, error: `战斗状态错误 - 期望: ${BATTLE_STATUS_NAMES.running}, 实际: ${statusName}` };
        }

        // 检查是否已初始化
        if (!battleMem.players || battleMem.players.length === 0) {
            return { valid: false, error: '战斗系统未初始化, 请先执行init命令' };
        }

        // 检查玩家是否存在
        if (battleMem.players.indexOf(player) === -1) {
            return { valid: false, error: `未知玩家: ${player}` };
        }

        return { valid: true };
    }

    /**
     * 玩家命令集的合法性校验
     * @param battleMem 战斗缓存模型
     * @param player 玩家名称
     * @param playerCommands 玩家命令列表
     * @returns 验证结果
     */
    public validatePlayerCommandsOwner(
        battleMem: BattleMemModel,
        player: string,
        playerCommands: CommandParam<keyof CommandParamMap>[]
    ): { valid: boolean; error?: string } {

        // 检查当前玩家的命令中是否有其他人的命令
        for (const command of playerCommands) {
            if (command.player !== player) {
                return { valid: false, error: `检测到玩家 ${player} 的命令中包含其他玩家 ${command.player} 的命令` };
            }
        }

        // 检查玩家是否已经在该回合提交过命令
        if (battleMem.currentRoundCommands[player]) {
            return { valid: false, error: `玩家 ${player} 在第 ${battleMem.currentRound} 回合已经提交过命令，不能重复提交` };
        }

        return { valid: true };
    }

    /**
     * 验证单条基础命令有效性
     * @param cmd 命令
     * @param battleMem 战斗缓存模型
     * @returns 验证结果
     */
    public validateBasicCommand(
        cmd: CommandParam<keyof CommandParamMap>,
        battleMem: BattleMemModel
    ): { valid: boolean; notValidMsg?: string; entityKey?: string } {
        // 检查战斗状态
        if (battleMem.status !== BattleStatus.running) {
            return { valid: false, notValidMsg: `战斗状态错误 - 期望: ${BattleStatus.running}, 实际: ${battleMem.status}` };
        }

        // 检查是否是结束命令
        if (cmd.type === CommandType.end) {
            return { valid: false, notValidMsg: '不允许发送结束命令，拒绝执行' };
        }

        // 检查命令格式
        if (!cmd || !cmd.player || !cmd.type) {
            return { valid: false, notValidMsg: '命令格式验证失败' };
        }

        // 检查命令类型
        const validCommandTypes = [
            CommandType.move,
            CommandType.attack,
            CommandType.build,
            CommandType.swap,
            CommandType.heal,
            CommandType.collect,
        ];
        if (!validCommandTypes.includes(cmd.type)) {
            const commandTypeNames = COMMAND_TYPE_NAMES;
            const validNames = validCommandTypes.map((type) => commandTypeNames[type]).join(', ');
            const actualName = commandTypeNames[cmd.type] || cmd.type;
            return { valid: false, notValidMsg: `命令类型错误 - 期望: ${validNames}, 实际: ${actualName}` };
        }

        // 检查同一回合中实体不能操作多次
        if (cmd.param && 'self' in cmd.param) {
            const self = (cmd.param as any).self;
            const entityKey = `${cmd.round}-${cmd.player}-${self.type}-${self.id}`;
            if (battleMem.currentRoundEntities.has(entityKey)) {
                return {valid: false, notValidMsg: `同一回合中实体 ${entityKey} 不能操作多次`, entityKey,};
            }

            // 检查当前回合新生产的实体不能有命令行为
            if (battleMem.currentRoundNewEntities.has(entityKey)) {
                let entityTypeName = COMMON_NAMES.unknownEntity;
                const entityConfig = this.getEntityConfig(self.type, self.id);
                if (entityConfig.valid) {
                    entityTypeName = entityConfig.config.name;
                }
                return {valid: false, notValidMsg: `当前回合新生产的${entityTypeName}(${entityKey})本回合不能执行命令`, entityKey,};
            }

            // 返回entityKey以便BattleSystem将其添加到集合中
            return { valid: true, entityKey };
        }

        return { valid: true };
    }

    /**
     * 检查目标位置是否为空位
     * @param position 目标位置
     * @returns 检查结果
     */
    public isPositionEmpty(position: { x: number; y: number }): { valid: boolean; error?: string } {
        const tileType = this.map.map[position.y][position.x].type;

        // 检查目标位置是否是平地（河流不能移动穿越）
        if (tileType !== TildeType.flat) {
            const terrainName = TERRAIN_NAMES[tileType] || COMMON_NAMES.unknownTerrain;
            return {
                valid: false,
                error: `地形类型错误 - 期望: 平地, 实际: ${terrainName} 位置: (${position.x},${position.y})`,
            };
        }

        // 使用通用方法检查实体占用
        const entityCheck = this.validateEntityAtPosition(position);
        if (!entityCheck.valid) {
            return { valid: false, error:entityCheck.error };
        }

        return { valid: true };
    }

    /**
     * 检查位置信息是否正确（所有命令的位置检查统一入口）
     * @param self 执行者（单位或建筑）
     * @param selfEntityType 执行者实体类型
     * @param offsetPosition 偏移位置
     * @param commandType 命令类型
     * @param target 目标（可选）（攻击、治疗命令用）
     * @returns 检查结果
     */
    public checkPosition(
        self: UnitModel | BuildingModel,
        selfEntityType: EntityType,
        offsetPosition: { x: number; y: number },
        commandType: CommandType,
        target?: UnitModel | BuildingModel
    ): { valid: boolean; error?: string } {

        // 计算目标位置的绝对坐标并检查是否越界
        const boundsValidation = this.validateMapBounds(self, offsetPosition);
        if (!boundsValidation.valid) {
            return boundsValidation;
        }

        // 检查行为方向是否有效（只允许水平或垂直） 只有生产可矩阵范围
        if (commandType !== CommandType.swap) {
            const directionValidation = this.validateDirection(offsetPosition);
            if (!directionValidation.valid) {
                return directionValidation;
            }
        }

        // 检查生产命令的矩阵范围
        if (commandType === CommandType.swap){
            const rangeCheck = this.validateBaseProduceRange(self as BuildingModel, offsetPosition);
            if (!rangeCheck.valid) {
                return rangeCheck;
            }
        }

        // 检查是否为同位置 只有治疗可原地
        if (commandType !== CommandType.heal) {
            const samePositionValidation = this.validateSamePosition(offsetPosition);
            if (!samePositionValidation.valid) {
                return samePositionValidation;
            }
        }

        const targetPosition = {
            x: self.position.x + offsetPosition.x,
            y: self.position.y + offsetPosition.y,
        };

        // 根据命令类型进行特殊处理
        switch (commandType) {
            case CommandType.move:
                // 移动命令：检查目标位置是否可移动
                return this.validateMovePosition(self, offsetPosition);

            case CommandType.attack:
                // 攻击命令：需要目标，检查攻击位置和路径
                if (!target) {
                    return { valid: false, error: '攻击命令缺少目标参数' };
                }
                return this.validateTargetPosition(self, selfEntityType, offsetPosition, target);

            case CommandType.heal:
                // 治疗命令：需要目标，检查治疗位置和路径
                if (!target) {
                    return { valid: false, error: '治疗命令缺少目标参数' };
                }
                return this.validateTargetPosition(self, selfEntityType, offsetPosition, target);

            case CommandType.collect:
                // 采集命令：检查采集方向和距离
                return this.validateCollectPosition(self, offsetPosition);

            case CommandType.build:
                // 建造命令：检查建造位置是否为空
                return this.isPositionEmpty(targetPosition);

            case CommandType.swap:
                // 生产命令：检查生产位置是否为空
                return this.isPositionEmpty(targetPosition);

            default:
                return { valid: false, error: `不支持的命令类型: ${commandType}` };
        }
    }

    /**
     * 检查指定位置是否有实体（单位或建筑）
     * @param position 要检查的位置
     * @returns 检查结果，包含实体信息
     */
    private validateEntityAtPosition(position: { x: number; y: number }): {valid: boolean;error?: string;} {
        // 检查是否有单位
        const unitAtPosition = this.map.getUnitAt(position);
        if (unitAtPosition) {
            const unitName = UnitConfig[unitAtPosition.type]?.name || COMMON_NAMES.unknownUnit;
            return {
                valid: false,
                error: `路径单位占用 - 期望: 位置(${position.x},${position.y})为空, 实际: 有单位(ID:${unitAtPosition.id}, 类型:${unitName}, 玩家:${unitAtPosition.player})`,
            };
        }

        // 检查是否有建筑
        const buildingAtPosition = this.map.getBuildingAt(position);
        if (buildingAtPosition) {
            const buildingName = BuildingConfig[buildingAtPosition.type]?.name || COMMON_NAMES.unknownBuilding;
            return {
                valid: false,
                error: `路径建筑占用 - 期望: 位置(${position.x},${position.y})为空, 实际: 有建筑(ID:${buildingAtPosition.id}, 类型:${buildingName}, 玩家:${buildingAtPosition.player})`,
            };
        }

        return { valid: true};
    }

    /**
     * 检查指定位置是否有建筑
     * @param position 要检查的位置
     * @returns 检查结果，包含实体信息
     */
    private validateBuildingAtPosition(position: { x: number; y: number }): {valid: boolean;error?: string;} {

        // 检查是否有建筑
        const buildingAtPosition = this.map.getBuildingAt(position);
        if (buildingAtPosition) {
            const buildingName = BuildingConfig[buildingAtPosition.type]?.name || COMMON_NAMES.unknownBuilding;
            return {
                valid: false,
                error: `路径建筑占用 - 期望: 位置(${position.x},${position.y})为空, 实际: 有建筑(ID:${buildingAtPosition.id}, 类型:${buildingName}, 玩家:${buildingAtPosition.player})`,
            };
        }

        return { valid: true};
    }

    /**
     * 验证行为方向（只允许水平或垂直）
     * @param offsetPosition 偏移位置
     * @returns 验证结果
     */
    private validateDirection(offsetPosition: { x: number; y: number }): { valid: boolean; error?: string } {
        const { x, y } = offsetPosition;
        if (x !== 0 && y !== 0) {
            return {
                valid: false,
                error: `行为方向错误 - 期望: 只能水平或垂直操作(x=0或y=0), 实际: 偏移量(${x},${y})为斜向`,
            };
        }
        return { valid: true };
    }

    /**
     * 验证基地生产范围
     * @param self 基地建筑
     * @param offsetPosition 偏移位置
     * @returns 验证结果
     */
    private validateBaseProduceRange(
        self: BuildingModel,
        offsetPosition: { x: number; y: number }
    ): { valid: boolean; error?: string } {
        // 获取基地的生产范围（使用attackRange）
        const produceRange = BuildingConfig[self.type].attackRange;

        // 计算距离（矩阵范围，允许斜向）
        const deltaX = Math.abs(offsetPosition.x);
        const deltaY = Math.abs(offsetPosition.y);

        // 检查是否在生产范围内（矩阵范围）
        if (deltaX > produceRange || deltaY > produceRange) {
            return {
                valid: false,
                error: `生产距离超出范围 - 期望: 生产距离≤${produceRange}, 实际: 距离=(${deltaX},${deltaY}) (从基地(${self.position.x},${self.position.y})到目标位置(${self.position.x + offsetPosition.x},${self.position.y + offsetPosition.y}))`
            };
        }

        return { valid: true };
    }

    /**
     * 验证是否同位置
     * @param offsetPosition 偏移位置
     * @returns 验证结果
     */
    private validateSamePosition(offsetPosition: { x: number; y: number }): { valid: boolean; error?: string } {
        if (offsetPosition.x === 0 && offsetPosition.y === 0) {
            return {
                valid: false,
                error: `行为方向错误 - 期望: 行为者和目标不能在同一位置, 实际: 位置相同`,
            };
        }
        return { valid: true };
    }

    /**
     * 检查位置的地形是否可攻击
     * @param position 要检查的位置
     * @returns 检查结果
     */
    private validateTerrainAtPosition(position: { x: number; y: number }): { valid: boolean; error?: string } {
        const tileType = this.map.map[position.y][position.x].type;

        // 检查地形是否阻隔
        if (tileType !== TildeType.flat && tileType !== TildeType.river) {
            const terrainName = tileType === TildeType.hill ? TERRAIN_TYPE_NAMES.hill : COMMON_NAMES.unknownTerrain;
            return {
                valid: false,
                error: `行为路径地形阻隔 - 期望: 平地或河流, 实际: ${terrainName} 位置: (${position.x},${position.y})`,
            };
        }

        return { valid: true };
    }

    /**
     * 检查路径上是否有障碍物（地形、建筑）
     * @param position 要检查的位置
     * @returns 检查结果
     */
    private validatePathObstacle(position: { x: number; y: number }): { valid: boolean; error?: string } {
        // 使用通用方法检查地形阻隔
        const terrainCheck = this.validateTerrainAtPosition(position);
        if (!terrainCheck.valid) {
            return { valid: false, error: terrainCheck.error };
        }

        // 使用通用方法检查建筑阻隔
        const buildingCheck = this.validateBuildingAtPosition(position);
        if (!buildingCheck.valid) {
            return { valid: false, error: buildingCheck.error };
        }

        return { valid: true };
    }

    /**
     * 验证移动行为
     * @param self 执行者
     * @param offsetPosition 偏移位置
     * @returns 验证结果
     */
    private validateMovePosition(
        self: UnitModel | BuildingModel,
        offsetPosition: { x: number; y: number }
    ): { valid: boolean; error?: string } {
        const targetPosition = {
            x: self.position.x + offsetPosition.x,
            y: self.position.y + offsetPosition.y
        };

        // 检查目标位置是否为空
        const targetPositionCheck = this.isPositionEmpty(targetPosition);
        if (!targetPositionCheck.valid) {
            return targetPositionCheck;
        }

        // 检查移动距离是否超过速度限制
        const distance = Math.max(Math.abs(offsetPosition.x), Math.abs(offsetPosition.y));
        const speed = (self as UnitModel).speed;
        if (distance > speed) {
            return {
                valid: false,
                error: `移动距离超出速度限制 - 期望: 移动距离≤${speed}, 实际: 移动距离=${distance} (从(${self.position.x},${self.position.y})到(${targetPosition.x},${targetPosition.y}))`
            };
        }

        // 检查移动路径上是否有阻隔（当速度大于1时）
        if (speed > 1) {
            return this.validatePath(self.position, offsetPosition, CommandType.move);
        }

        return { valid: true };
    }

    /**
     * 验证行为目标位置 (攻击、治疗)
     * @param self 执行者
     * @param selfEntityType 执行者实体类型
     * @param offsetPosition 偏移位置
     * @param target 目标实体
     * @returns 验证结果
     */
    private validateTargetPosition(
        self: UnitModel | BuildingModel,
        selfEntityType: EntityType,
        offsetPosition: { x: number; y: number },
        target: UnitModel | BuildingModel,
    ): { valid: boolean; error?: string } {
        const targetPosition = {
            x: self.position.x + offsetPosition.x,
            y: self.position.y + offsetPosition.y
        };

        // 检查目标位置是否正确
        if (target.position.x !== targetPosition.x || target.position.y !== targetPosition.y) {
            return {
                valid: false,
                error: `目标位置错误 - 期望: 目标位置(${targetPosition.x},${targetPosition.y}), 实际: 目标位置(${target.position.x},${target.position.y})`,
            };
        }

        // 检查行为范围
        const distance = Math.max(Math.abs(offsetPosition.x), Math.abs(offsetPosition.y));
        let attackRange = 1;
        if (selfEntityType === EntityType.unit) {
            attackRange = UnitConfig[(self as UnitModel).type].attackRange;
        }else if (selfEntityType === EntityType.building) {
            attackRange = BuildingConfig[(self as BuildingModel).type].attackRange;
        }
         if (distance > attackRange) {
            return {
                valid: false,
                error: `行为距离超出范围 - 期望: 行为距离≤${attackRange}, 实际: 行为距离=${distance} (从(${self.position.x},${self.position.y})到(${target.position.x},${target.position.y}))`,
            };
        }

        // 检查行为路径上是否有阻隔（当攻击范围大于1时）
        if (attackRange > 1) {
            return this.validatePath(self.position, offsetPosition, CommandType.attack);
        }

        return { valid: true };
    }

    /**
     * 验证采集位置和条件
     * @param self 执行采集的实体
     * @param offsetPosition 偏移位置
     * @returns 验证结果
     */
    private validateCollectPosition(
        self: UnitModel | BuildingModel,
        offsetPosition: { x: number; y: number }
    ): { valid: boolean; error?: string } {
        const targetPosition = {
            x: self.position.x + offsetPosition.x,
            y: self.position.y + offsetPosition.y
        };

        // 获取目标点的地形是否为资源地形
        const targetTildeType = this.map.map[targetPosition.y][targetPosition.x].type;
        if (!isResourceTildeType(targetTildeType)) {
            return { valid: false, error: '目标位置不是可采集的资源类型' };
        }

        // 检查采集范围
        const distance = Math.max(Math.abs(offsetPosition.x), Math.abs(offsetPosition.y));
        const collectRange = UnitConfig[(self as UnitModel).type].attackRange;
        if (distance > collectRange) {
            return {
                valid: false,
                error: `行为距离超出范围 - 期望: 采集距离≤${collectRange}, 实际: 采集距离=${distance} (从(${self.position.x},${self.position.y})到(${targetPosition.x},${targetPosition.y}))`,
            };
        }

        return { valid: true };
    }

    /**
     * 验证路径是否畅通（通用函数）
     * @param selfPosition 起始位置
     * @param offsetPosition 偏移位置
     * @param commandType 命令类型，决定使用哪种检查方式
     * @returns 验证结果
     */
    private validatePath(
        selfPosition: { x: number; y: number },
        offsetPosition: { x: number; y: number },
        commandType: CommandType
    ): { valid: boolean; error?: string } {
        const targetPosition = {
            x: selfPosition.x + offsetPosition.x,
            y: selfPosition.y + offsetPosition.y
        };

        const isMoveCommand = commandType === CommandType.move;

        if (offsetPosition.x !== 0) {
            const step = offsetPosition.x > 0 ? 1 : -1;
            for (let x1 = selfPosition.x + step; x1 !== targetPosition.x; x1 += step) {
                const checkPos = { x: x1, y: targetPosition.y };
                const checkResult = isMoveCommand ? this.isPositionEmpty(checkPos): this.validatePathObstacle(checkPos);
                return checkResult;
            }
        } else if (offsetPosition.y !== 0) {
            const step = offsetPosition.y > 0 ? 1 : -1;
            for (let y1 = selfPosition.y + step; y1 !== targetPosition.y; y1 += step) {
                const checkPos = { x: targetPosition.x, y: y1 };
                const checkResult = isMoveCommand ? this.isPositionEmpty(checkPos): this.validatePathObstacle(checkPos);
                return checkResult;
            }
        }

        return { valid: true };
    }

    /**
     * 通用命令类型校验
     * @param cmd 命令对象
     * @param expectedType 期望的命令类型
     * @returns 校验结果
     */
    private validateCommandType<T extends keyof CommandParamMap>(
        cmd: CommandParam<T>,
        expectedType: T
    ): { valid: boolean; error?: string } {
        if (cmd.type !== expectedType) {
            return { valid: false, error: `命令类型错误 - 期望: ${expectedType}, 实际: ${cmd.type}` };
        }
        return { valid: true };
    }

    /**
     * 通用参数存在性校验
     * @param param 参数对象
     * @param commandName 命令名称（用于错误信息）
     * @returns 校验结果
     */
    private validateParamExists(
        param: any,
        commandName: string
    ): { valid: boolean; error?: string } {
        if (!param) {
            return { valid: false, error: `${commandName}命令缺少参数 - 期望: 包含param对象, 实际: param为空` };
        }
        return { valid: true };
    }

    /**
     * 通用self参数校验
     * @param self self参数
     * @param expectedTypes 期望的实体类型数组
     * @param commandName 命令名称（用于错误信息）
     * @param commandPlayer 命令执行者的玩家ID
     * @returns 校验结果
     */
    private validateSelfParam(
        self: any,
        expectedTypes: EntityType[],
        commandName: string
    ): { valid: boolean; error?: string } {
        if (!self) {
            return { valid: false, error: `${commandName}命令缺少self参数 - 期望: 包含self对象, 实际: self为空` };
        }

        if (!expectedTypes.includes(self.type)) {
            const typeNames = expectedTypes.map(type => ENTITY_TYPE_NAMES[type] || COMMON_NAMES.unknownType).join('或');
            const actualTypeName = ENTITY_TYPE_NAMES[self.type] || COMMON_NAMES.unknownType;
            return { valid: false, error: `${commandName}者类型错误 - 期望: ${typeNames}, 实际: ${actualTypeName}` };
        }

        return { valid: true };
    }

    /**
     * 通用target参数校验
     * @param target target参数
     * @param expectedTypes 期望的实体类型数组
     * @param commandName 命令名称（用于错误信息）
     * @param required 是否必需
     * @returns 校验结果
     */
    private validateTargetParam(
        target: any,
        expectedTypes: EntityType[],
        commandName: string,
        required: boolean = true
    ): { valid: boolean; error?: string } {
        if (!target) {
            if (required) {
                return { valid: false, error: `${commandName}命令缺少target参数 - 期望: 包含target对象, 实际: target为空` };
            }
            return { valid: true };
        }

        if (!expectedTypes.includes(target.type)) {
            const typeNames = expectedTypes.map(type => ENTITY_TYPE_NAMES[type] || COMMON_NAMES.unknownType).join('或');
            const actualTypeName = ENTITY_TYPE_NAMES[target.type] || COMMON_NAMES.unknownType;
            return { valid: false, error: `${commandName}目标类型错误 - 期望: ${typeNames}, 实际: ${actualTypeName}` };
        }

        return { valid: true };
    }

    /**
     * 校验offsetPosition参数是否存在
     * @param offsetPosition 要检查的offsetPosition参数
     * @param commandName 命令名称，用于错误信息
     * @returns 校验结果
     */
    private validateOffsetPositionParam(
        offsetPosition: any,
        commandName: string
    ): { valid: boolean; error?: string } {
        if (!offsetPosition) {
            return {
                valid: false,
                error: `${commandName}命令缺少offsetPosition参数 - 期望: 包含offsetPosition对象, 实际: offsetPosition为空`
            };
        }
        return { valid: true };
    }

    /**
     * 通用实体存在性校验
     * @param entityType 实体类型
     * @param entityId 实体ID
     * @param entityRole 实体角色（用于错误信息，如"攻击者"、"目标"等）
     * @returns 校验结果和实体对象
     */
    private validateEntityExists(
        entityType: EntityType,
        entityId: number,
        entityRole: string
    ): { valid: boolean; error?: string; entity?: UnitModel | BuildingModel } {
        const entity = this.getEntity(entityType, entityId);
        if (!entity) {
            let entityTypeName = COMMON_NAMES.unknownEntity;
            const entityConfig = this.getEntityConfig(entityType, entityId);
            if (entityConfig.valid) {
                entityTypeName = entityConfig.config.name;
            }
            return {
                valid: false,
                error: `${entityRole}不存在 - 期望: 找到${entityTypeName}(ID:${entityId}), 实际: 实体不存在`
            };
        }
        return { valid: true, entity };
    }

    /**
     * 通用建筑类型能力校验
     * @param building 建筑对象
     * @param commandType 命令类型
     * @returns 校验结果
     */
    private validateBuildingCapability(
        building: BuildingModel,
        commandType: CommandType
    ): { valid: boolean; error?: string } {
        const buildingName = BuildingConfig[building.type]?.name || COMMON_NAMES.unknownBuilding;

        switch (commandType) {
            case CommandType.attack:
                // 只有防御塔有攻击能力
                if (building.type !== BuildingType.tower) {
                    return {
                        valid: false,
                        error: `建筑类型无法攻击 - 期望: 防御塔, 实际: ${buildingName}(${building.type})无攻击能力`
                    };
                }
                break;
            case CommandType.swap:
                // 只有基地有生产能力
                if (building.type !== BuildingType.base) {
                    return {
                        valid: false,
                        error: `建筑类型无法生产 - 期望: 基地, 实际: ${buildingName}(${building.type})无生产能力`
                    };
                }
                break;
            default:
                return {
                    valid: false,
                    error: `建筑不支持的命令类型: ${commandType}`
                };
        }

        return { valid: true };
    }

    /**
     * 通用单位类型能力校验
     * @param unit 单位对象
     * @param commandType 命令类型
     * @returns 校验结果
     */
    private validateUnitCapability(
        unit: UnitModel,
        commandType: CommandType,
    ): { valid: boolean; error?: string } {

        const unitName = UnitConfig[unit.type]?.name || COMMON_NAMES.unknownUnit;

        switch (commandType) {
            case CommandType.attack:
                // 只有战士、弓箭手有攻击能力
                if (unit.type !== UnitType.soldier && unit.type !== UnitType.archer) {
                    return {
                        valid: false,
                        error: `单位类型无法攻击 - 期望: 战士或弓箭手, 实际: ${unitName}(${unit.type})无攻击能力`
                    };
                }
                break;
            case CommandType.heal:
                if (unit.type !== UnitType.doctor) {
                    return {
                        valid: false,
                        error: `单位类型无法治疗 - 期望: 治疗兵, 实际: ${unitName}(${unit.type})无治疗能力`
                    };
                }
                break;
            case CommandType.collect:
                if (unit.type !== UnitType.collect) {
                    return {
                        valid: false,
                        error: `单位类型无法采集 - 期望: 采集兵, 实际: ${unitName}(${unit.type})无采集能力`
                    };
                }
                break;
            case CommandType.build:
                if (unit.type !== UnitType.worker) {
                    return {
                        valid: false,
                        error: `单位类型无法建造 - 期望: 建造兵, 实际: ${unitName}(${unit.type})无建造能力`
                    };
                }
                break;
            default:
                return {
                    valid: false,
                    error: `不支持的命令类型: ${commandType}`
                };
        }

        return { valid: true };
    }

    /**
     * 通用友军检查
     * @param self 执行者
     * @param target 目标
     * @param commandType 命令类型
     * @param shouldBeFriendly 是否应该是友军（true表示只能对友军，false表示只能对敌军）
     * @returns 校验结果
     */
    private validatePlayerRelation(
        self: UnitModel | BuildingModel,
        target: UnitModel | BuildingModel,
        commandType: CommandType,
        shouldBeFriendly: boolean
    ): { valid: boolean; error?: string } {
        const isFriendly = self.player === target.player;

        // 根据命令类型获取动作名称
        const actionName = COMMAND_TYPE_NAMES[commandType];

        if (shouldBeFriendly && !isFriendly) {
            return {
                valid: false,
                error: `不能${actionName}敌军 - 期望: ${actionName}者(${self.player})与目标(${target.player})属于同一玩家, 实际: 属于不同玩家`
            };
        }

        if (!shouldBeFriendly && isFriendly) {
            return {
                valid: false,
                error: `不能${actionName}友军 - 期望: ${actionName}敌军, 实际: ${actionName}己方实体(ID:${target.id}, 玩家:${target.player})`
            };
        }

        return { valid: true };
    }

    /**
     * 校验实体归属权
     * @param entity 实体模型（UnitModel 或 BuildingModel）
     * @param expectedPlayer 期望的玩家ID
     * @param commandName 命令名称（用于错误信息）
     * @returns 校验结果
     */
    private validateEntityOwnership(
        entity: UnitModel | BuildingModel,
        expectedPlayer: string,
        commandName: string
    ): { valid: boolean; error?: string } {
        if (entity.player !== expectedPlayer) {
            return {
                valid: false,
                error: `${commandName}命令的实体归属权错误 - 期望: 属于玩家${expectedPlayer}, 实际: 属于玩家${entity.player}`
            };
        }

        return { valid: true };
    }

    /**
     * 通用资源校验方法
     * @param player 玩家对象
     * @param requiredCost 所需资源
     * @returns 校验结果
     */
    private validatePlayerResources(
        player: any,
        requiredCost: number,
    ): { valid: boolean; error?: string } {
        if (!player) {
            return {
                valid: false,
                error: `玩家不存在 - 期望: 找到有效玩家, 实际: 玩家不存在`
            };
        }

        const playerRmb = player.getRmb();
        if (playerRmb < requiredCost) {
            return {
                valid: false,
                error: `资源不足 - 期望: ≥${requiredCost}, 实际: ${playerRmb} (缺少${requiredCost - playerRmb})`
            };
        }

        return { valid: true };
    }

    /**
     * 通用单位类型有效性校验
     * @param unitType 单位类型
     * @returns 校验结果
     */
    private validateUnitType(unitType: UnitType): { valid: boolean; error?: string } {
        if (!Object.values(UnitType).includes(unitType)) {
            const validTypes = Object.values(UnitType)
                .map((type) => UnitConfig[type]?.name || COMMON_NAMES.unknownUnit)
                .join(', ');
            const actualName = UnitConfig[unitType]?.name || COMMON_NAMES.unknownUnit;
            return {
                valid: false,
                error: `单位类型无效 - 期望: [${validTypes}]中的一种, 实际: ${actualName}`
            };
        }
        return { valid: true };
    }

    /**
     * 通用建筑类型有效性校验
     * @param buildingType 建筑类型
     * @param allowedTypes 允许的建筑类型列表
     * @returns 校验结果
     */
    private validateBuildingType(
        buildingType: BuildingType,
        allowedTypes: BuildingType[]
    ): { valid: boolean; error?: string } {
        if (!allowedTypes.includes(buildingType)) {
            const buildingNames = allowedTypes
                .map((type) => BuildingConfig[type]?.name || COMMON_NAMES.unknownBuilding)
                .join(', ');
            const actualName = BuildingConfig[buildingType]?.name || COMMON_NAMES.unknownBuilding;
            return {
                valid: false,
                error: `建筑类型无效 - 期望: [${buildingNames}]中的一种, 实际: ${actualName}`
            };
        }
        return { valid: true };
    }

    /**
     * 校验位置是否在地图边界内
     * @param self 执行者
     * @param offsetPosition 偏移位置
     * @returns 校验结果
     */
    private validateMapBounds(
        self: UnitModel | BuildingModel,
        offsetPosition: { x: number; y: number },
    ): { valid: boolean; error?: string } {
        const position = {
            x: self.position.x + offsetPosition.x,
            y: self.position.y + offsetPosition.y,
        };
        const mapWidth = this.map.map[0].length;
        const mapHeight = this.map.map.length;
        if (position.x < 0 || position.x >= mapWidth || position.y < 0 || position.y >= mapHeight) {
            return {
                valid: false,
                error: `行为超出地图边界 - 期望: X坐标[0-${mapWidth-1}], Y坐标[0-${mapHeight-1}], 实际: (${position.x}, ${position.y})`
            };
        }
        return { valid: true };
    }

    /**
     * 检查攻击命令是否有效
     * @param cmd 攻击命令
     * @returns 检查结果
     */
    public checkAttack(cmd: CommandParam<CommandType.attack>): { valid: boolean; error: string } {
        // 使用公共方法检查命令类型
        const typeCheck = this.validateCommandType(cmd, CommandType.attack);
        if (!typeCheck.valid) {
            return { valid: false, error: typeCheck.error };
        }

        // 使用公共方法检查参数存在性
        const paramCheck = this.validateParamExists(cmd.param, COMMAND_TYPE_NAMES[CommandType.attack]);
        if (!paramCheck.valid) {
            return { valid: false, error: paramCheck.error };
        }

        const param = cmd.param;

        // 使用公共方法检查self参数
        const selfCheck = this.validateSelfParam(param.self, [EntityType.unit, EntityType.building], COMMAND_TYPE_NAMES[CommandType.attack]);
        if (!selfCheck.valid) {
            return { valid: false, error: selfCheck.error };
        }

        // 使用公共方法检查target参数
        const targetCheck = this.validateTargetParam(param.target, [EntityType.unit, EntityType.building], COMMAND_TYPE_NAMES[CommandType.attack]);
        if (!targetCheck.valid) {
            return { valid: false, error: targetCheck.error };
        }

        // 使用公共方法检查offsetPosition参数
        const offsetPositionCheck = this.validateOffsetPositionParam(param.offsetPosition, COMMAND_TYPE_NAMES[CommandType.attack]);
        if (!offsetPositionCheck.valid) {
            return { valid: false, error: offsetPositionCheck.error };
        }

        // 使用公共方法获取和校验攻击者实体
        const selfEntityCheck = this.validateEntityExists(param.self.type, param.self.id, ENTITY_ROLE_NAMES.attacker);
        if (!selfEntityCheck.valid) {
            return { valid: false, error: selfEntityCheck.error };
        }
        const selfEntity = selfEntityCheck.entity;

        // 校验攻击者实体归属权
        const ownershipCheck = this.validateEntityOwnership(selfEntity, cmd.player, COMMAND_TYPE_NAMES[CommandType.attack]);
        if (!ownershipCheck.valid) {
            return { valid: false, error: ownershipCheck.error };
        }

        // 使用公共方法获取和校验目标实体
        const targetEntityCheck = this.validateEntityExists(param.target.type, param.target.id, ENTITY_ROLE_NAMES.attackTarget);
        if (!targetEntityCheck.valid) {
            return { valid: false, error: targetEntityCheck.error };
        }
        const targetEntity = targetEntityCheck.entity;

        // 使用公共方法检查攻击者类型是否有攻击能力
        if (param.self.type === EntityType.unit) {
            const capabilityCheck = this.validateUnitCapability(selfEntity as UnitModel, CommandType.attack);
            if (!capabilityCheck.valid) {
                return { valid: false, error: capabilityCheck.error };
            }
        } else if (param.self.type === EntityType.building) {
            const capabilityCheck = this.validateBuildingCapability(selfEntity as BuildingModel, CommandType.attack);
            if (!capabilityCheck.valid) {
                return { valid: false, error: capabilityCheck.error };
            }
        }

        // 使用公共方法检查是否攻击己方单位/建筑
        const relationCheck = this.validatePlayerRelation(selfEntity, targetEntity, CommandType.attack, false);
        if (!relationCheck.valid) {
            return { valid: false, error: relationCheck.error };
        }

        // 检查如果攻击目标是基地且血量小于等于0，则不允许攻击
        if (param.target.type === EntityType.building && (targetEntity as BuildingModel).type === BuildingType.base && targetEntity.hp <= 0) {
            return {
                valid: false,
                error: `不能攻击已被摧毁的基地 - 期望: 攻击有效目标, 实际: 基地(ID:${targetEntity.id})血量为${targetEntity.hp}`,
            };
        }

        // 检查位置信息是否正确
        const checkResult = this.checkPosition(selfEntity, param.self.type, param.offsetPosition, CommandType.attack, targetEntity);
        if (!checkResult.valid) {
            return { valid: false, error: checkResult.error };
        }

        return { valid: true, error: '' };
    }

    /**
     * 检查生产单位命令是否有效
     * @param cmd 生产单位命令
     * @returns 检查结果
     */
    public checkSwap(cmd: CommandParam<CommandType.swap>): { valid: boolean; error?: string } {
        // 使用公共方法检查命令类型
        const typeCheck = this.validateCommandType(cmd, CommandType.swap);
        if (!typeCheck.valid) {
            return { valid: false, error: typeCheck.error };
        }

        // 使用公共方法检查参数存在性
        const paramCheck = this.validateParamExists(cmd.param, COMMAND_TYPE_NAMES[CommandType.swap]);
        if (!paramCheck.valid) {
            return { valid: false, error: paramCheck.error };
        }

        const param = cmd.param;

        // 使用公共方法检查self参数（必须是建筑）
        const selfCheck = this.validateSelfParam(param.self, [EntityType.building], COMMAND_TYPE_NAMES[CommandType.swap]);
        if (!selfCheck.valid) {
            return { valid: false, error: selfCheck.error };
        }

        // 使用公共方法检查target参数（必须是单位）
        const targetCheck = this.validateTargetParam(param.target, [EntityType.unit], COMMAND_TYPE_NAMES[CommandType.swap]);
        if (!targetCheck.valid) {
            return { valid: false, error: targetCheck.error };
        }

        // 使用公共方法检查offsetPosition参数
        const offsetPositionCheck = this.validateOffsetPositionParam(param.offsetPosition, COMMAND_TYPE_NAMES[CommandType.swap]);
        if (!offsetPositionCheck.valid) {
            return { valid: false, error: offsetPositionCheck.error };
        }

        // 使用公共方法获取和校验生产建筑
        const selfEntityCheck = this.validateEntityExists(param.self.type, param.self.id, ENTITY_ROLE_NAMES.swapper);
        if (!selfEntityCheck.valid) {
            return { valid: false, error: selfEntityCheck.error };
        }
        const selfEntity = selfEntityCheck.entity as BuildingModel;

        // 校验生产建筑归属权
        const ownershipCheck = this.validateEntityOwnership(selfEntity, cmd.player, COMMAND_TYPE_NAMES[CommandType.swap]);
        if (!ownershipCheck.valid) {
            return { valid: false, error: ownershipCheck.error };
        }

        // 使用公共方法检查建筑是否有生产能力
        const capabilityCheck = this.validateBuildingCapability(selfEntity, CommandType.swap);
        if (!capabilityCheck.valid) {
            return { valid: false, error: capabilityCheck.error };
        }

        // 使用公共方法检查单位类型是否有效
        const unitType = param.target.utype;
        const unitTypeCheck = this.validateUnitType(unitType);
        if (!unitTypeCheck.valid) {
            return { valid: false, error: unitTypeCheck.error };
        }

        // 使用公共方法检查玩家资源是否足够
        const unitCost = UnitConfig[unitType].cost;
        const player = this.map.getPlayer(cmd.player);
        const resourceCheck = this.validatePlayerResources(player, unitCost);
        if (!resourceCheck.valid) {
            return { valid: false, error: resourceCheck.error };
        }

        // 检查位置信息是否正确
        const checkResult = this.checkPosition(selfEntity, param.self.type, param.offsetPosition, CommandType.swap);
        if (!checkResult.valid) {
            return { valid: false, error: checkResult.error };
        }

        return { valid: true };
    }

    /**
     * 检查移动命令是否有效
     * @param cmd 移动命令
     * @returns 检查结果
     */
    public checkMoveTo(cmd: CommandParam<CommandType.move>): { valid: boolean; error?: string } {
        // 使用公共方法检查命令类型
        const typeCheck = this.validateCommandType(cmd, CommandType.move);
        if (!typeCheck.valid) {
            return { valid: false, error: typeCheck.error };
        }

        // 使用公共方法检查参数存在性
        const paramCheck = this.validateParamExists(cmd.param, COMMAND_TYPE_NAMES[CommandType.move]);
        if (!paramCheck.valid) {
            return { valid: false, error: paramCheck.error };
        }

        const param = cmd.param;

        // 使用公共方法检查self参数（必须是单位）
        const selfCheck = this.validateSelfParam(param.self, [EntityType.unit], COMMAND_TYPE_NAMES[CommandType.move]);
        if (!selfCheck.valid) {
            return { valid: false, error: selfCheck.error };
        }

        // 使用公共方法检查offsetPosition参数
        const offsetPositionCheck = this.validateOffsetPositionParam(param.offsetPosition, COMMAND_TYPE_NAMES[CommandType.move]);
        if (!offsetPositionCheck.valid) {
            return { valid: false, error: offsetPositionCheck.error };
        }

        // 使用公共方法获取和校验移动单位
        const selfEntityCheck = this.validateEntityExists(param.self.type, param.self.id, ENTITY_ROLE_NAMES.mover);
        if (!selfEntityCheck.valid) {
            return { valid: false, error: selfEntityCheck.error };
        }
        const selfEntity = selfEntityCheck.entity as UnitModel;

        // 校验移动单位归属权
        const ownershipCheck = this.validateEntityOwnership(selfEntity, cmd.player, COMMAND_TYPE_NAMES[CommandType.move]);
        if (!ownershipCheck.valid) {
            return { valid: false, error: ownershipCheck.error };
        }

        // 检查位置信息是否正确
        const checkResult = this.checkPosition(selfEntity, param.self.type, param.offsetPosition, CommandType.move);
        if (!checkResult.valid) {
            return { valid: false, error: checkResult.error };
        }

        return { valid: true, error: '' };
    }

    /**
     * 检查建造命令是否有效
     * @param cmd 建造命令
     * @returns 检查结果
     */
    public checkBuild(cmd: CommandParam<CommandType.build>): { valid: boolean; error?: string } {
        // 使用公共方法检查命令类型
        const typeCheck = this.validateCommandType(cmd, CommandType.build);
        if (!typeCheck.valid) {
            return { valid: false, error: typeCheck.error };
        }

        // 使用公共方法检查参数存在性
        const paramCheck = this.validateParamExists(cmd.param, COMMAND_TYPE_NAMES[CommandType.build]);
        if (!paramCheck.valid) {
            return { valid: false, error: paramCheck.error };
        }

        const param = cmd.param;

        // 使用公共方法检查self参数（必须是单位）
        const selfCheck = this.validateSelfParam(param.self, [EntityType.unit], COMMAND_TYPE_NAMES[CommandType.build]);
        if (!selfCheck.valid) {
            return { valid: false, error: selfCheck.error };
        }

        // 使用公共方法检查target参数（必须是建筑）
        const targetCheck = this.validateTargetParam(param.target, [EntityType.building], COMMAND_TYPE_NAMES[CommandType.build]);
        if (!targetCheck.valid) {
            return { valid: false, error: targetCheck.error };
        }

        // 使用公共方法检查offsetPosition参数
        const offsetPositionCheck = this.validateOffsetPositionParam(param.offsetPosition, COMMAND_TYPE_NAMES[CommandType.build]);
        if (!offsetPositionCheck.valid) {
            return { valid: false, error: offsetPositionCheck.error };
        }

        // 使用公共方法获取和校验建造者单位
        const selfEntityCheck = this.validateEntityExists(param.self.type, param.self.id, ENTITY_ROLE_NAMES.builder);
        if (!selfEntityCheck.valid) {
            return { valid: false, error: selfEntityCheck.error };
        }
        const selfEntity = selfEntityCheck.entity as UnitModel;

        // 校验建造者单位归属权
        const ownershipCheck = this.validateEntityOwnership(selfEntity, cmd.player, COMMAND_TYPE_NAMES[CommandType.build]);
        if (!ownershipCheck.valid) {
            return { valid: false, error: ownershipCheck.error };
        }

        // 使用公共方法检查单位是否具备建造能力
        const capabilityCheck = this.validateUnitCapability(selfEntity, CommandType.build);
        if (!capabilityCheck.valid) {
            return { valid: false, error: capabilityCheck.error };
        }

        // 使用公共方法检查建筑类型是否有效, 玩家不能构建基地
        const buildingType = param.target.utype;
        const validBuildingTypes = [BuildingType.tower, BuildingType.wall];
        const buildingTypeCheck = this.validateBuildingType(buildingType, validBuildingTypes);
        if (!buildingTypeCheck.valid) {
            return { valid: false, error: buildingTypeCheck.error };
        }

        // 使用公共方法检查玩家资源是否足够
        const buildingCost = BuildingConfig[buildingType].cost;
        const player = this.map.getPlayer(cmd.player);
        const resourceCheck = this.validatePlayerResources(player, buildingCost);
        if (!resourceCheck.valid) {
            return { valid: false, error: resourceCheck.error };
        }

        // 检查位置信息是否正确
        const checkResult = this.checkPosition(selfEntity, param.self.type, param.offsetPosition, CommandType.build);
        if (!checkResult.valid) {
            return { valid: false, error: checkResult.error };
        }

        return { valid: true };
    }

    /**
     * 检查治疗命令是否有效
     * @param cmd 治疗命令
     * @returns 检查结果
     */
    public checkHeal(cmd: CommandParam<CommandType.heal>): { valid: boolean; error: string } {
        // 使用公共方法检查命令类型
        const typeCheck = this.validateCommandType(cmd, CommandType.heal);
        if (!typeCheck.valid) {
            return { valid: false, error: typeCheck.error };
        }

        // 使用公共方法检查参数存在性
        const paramCheck = this.validateParamExists(cmd.param, COMMAND_TYPE_NAMES[CommandType.heal]);
        if (!paramCheck.valid) {
            return { valid: false, error: paramCheck.error };
        }

        const param = cmd.param;

        // 使用公共方法检查self参数
        const selfCheck = this.validateSelfParam(param.self, [EntityType.unit], COMMAND_TYPE_NAMES[CommandType.heal]);
        if (!selfCheck.valid) {
            return { valid: false, error: selfCheck.error };
        }

        // 使用公共方法检查target参数
        const targetCheck = this.validateTargetParam(param.target, [EntityType.unit], COMMAND_TYPE_NAMES[CommandType.heal]);
        if (!targetCheck.valid) {
            return { valid: false, error: targetCheck.error };
        }

        // 使用公共方法检查治疗者是否存在
        const selfEntityCheck = this.validateEntityExists(EntityType.unit, param.self.id, ENTITY_ROLE_NAMES.healer);
        if (!selfEntityCheck.valid) {
            return { valid: false, error: selfEntityCheck.error };
        }

        // 使用公共方法检查治疗目标是否存在
        const targetEntityCheck = this.validateEntityExists(EntityType.unit, param.target.id, ENTITY_ROLE_NAMES.healTarget);
        if (!targetEntityCheck.valid) {
            return { valid: false, error: targetEntityCheck.error };
        }

        const selfEntity = selfEntityCheck.entity as UnitModel;
        const targetEntity = targetEntityCheck.entity as UnitModel;

        // 校验治疗者单位归属权
        const ownershipCheck = this.validateEntityOwnership(selfEntity, cmd.player, COMMAND_TYPE_NAMES[CommandType.heal]);
        if (!ownershipCheck.valid) {
            return { valid: false, error: ownershipCheck.error };
        }

        // 使用公共方法检查治疗者是否为治疗兵
        const capabilityCheck = this.validateUnitCapability(selfEntity, CommandType.heal);
        if (!capabilityCheck.valid) {
            return { valid: false, error: capabilityCheck.error };
        }

        // 使用公共方法检查玩家关系（治疗必须是友军）
        const relationCheck = this.validatePlayerRelation(selfEntity, targetEntity, CommandType.heal, true);
        if (!relationCheck.valid) {
            return { valid: false, error: relationCheck.error };
        }

        // 检查目标血量
        const maxHp = UnitConfig[targetEntity.type].hp;
        if (targetEntity.hp >= maxHp) {
            return {
                valid: false,
                error: `目标血量已满 - 期望: 血量<${maxHp}, 实际: ${targetEntity.hp}/${maxHp} (无需治疗)`
            };
        }

        // 检查位置信息是否正确
        const positionCheck = this.checkPosition(selfEntity, param.self.type, param.offsetPosition, CommandType.heal, targetEntity);
        if (!positionCheck.valid) {
            return { valid: false, error: positionCheck.error };
        }

        return { valid: true, error: '' };
    }

    /**
     * 检查采集命令是否有效
     * @param cmd 采集命令
     * @returns 检查结果
     */
    public checkCollect(cmd: CommandParam<CommandType.collect>): { valid: boolean; error: string } {
        // 使用公共方法检查命令类型
        const typeCheck = this.validateCommandType(cmd, CommandType.collect);
        if (!typeCheck.valid) {
            return { valid: false, error: typeCheck.error };
        }

        // 使用公共方法检查参数存在性
        const paramCheck = this.validateParamExists(cmd.param, COMMAND_TYPE_NAMES[CommandType.collect]);
        if (!paramCheck.valid) {
            return { valid: false, error: paramCheck.error };
        }

        const param = cmd.param;

        // 使用公共方法检查self参数
        const selfCheck = this.validateSelfParam(param.self, [EntityType.unit], COMMAND_TYPE_NAMES[CommandType.collect]);
        if (!selfCheck.valid) {
            return { valid: false, error: selfCheck.error };
        }

        // 使用公共方法检查target参数
        const targetCheck = this.validateTargetParam(param.target, [EntityType.terrain], COMMAND_TYPE_NAMES[CommandType.collect]);
        if (!targetCheck.valid) {
            return { valid: false, error: targetCheck.error };
        }

        // 使用公共方法检查offsetPosition参数
        const offsetPositionCheck = this.validateOffsetPositionParam(param.offsetPosition, COMMAND_TYPE_NAMES[CommandType.collect]);
        if (!offsetPositionCheck.valid) {
            return { valid: false, error: offsetPositionCheck.error };
        }

        // 使用公共方法检查采集者是否存在
        const selfEntityCheck = this.validateEntityExists(EntityType.unit, param.self.id, ENTITY_ROLE_NAMES.collector);
        if (!selfEntityCheck.valid) {
            return { valid: false, error: selfEntityCheck.error };
        }
        const selfEntity = selfEntityCheck.entity as UnitModel;

        // 校验采集者单位归属权
        const ownershipCheck = this.validateEntityOwnership(selfEntity, cmd.player, COMMAND_TYPE_NAMES[CommandType.collect]);
        if (!ownershipCheck.valid) {
            return { valid: false, error: ownershipCheck.error };
        }

        // 使用公共方法检查采集者是否为采集兵
        const capabilityCheck = this.validateUnitCapability(selfEntity, CommandType.collect);
        if (!capabilityCheck.valid) {
            return { valid: false, error: capabilityCheck.error };
        }

        // 检查位置信息是否正确
        const positionCheck = this.checkPosition(selfEntity, param.self.type, param.offsetPosition, CommandType.collect);
        if (!positionCheck.valid) {
            return { valid: false, error: positionCheck.error };
        }

        return { valid: true, error: '' };
    }
}
